home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / 3DTOSHI2.ZIP / mpgfx / source / Gfxvga.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-15  |  12.4 KB  |  531 lines
  1.  
  2. // gfxvga.cpp
  3. //
  4. // Copyright (c) 1995 by Toshiaki Tsuji, all rights reserved.
  5.  
  6. #include "stdgfx.h"
  7. #include "gfxvga.h"
  8. #include "lgfxvga.h"
  9. #include "lgfxdib.h"
  10.  
  11. VGADRIVER::VGADRIVER ()
  12.   {
  13.     Width = Height = 0;
  14.     Buffer = NULL;
  15.     Registers[VGA_INDEX_PORT] = 0x3CE;
  16.     Registers[VGA_DATA_PORT] = 0x3CF;
  17.     Registers[DAC_MASK] = 0x3C6;
  18.     Registers[DAC_READ] = 0x3C7;
  19.     Registers[DAC_WRITE] = 0x3C8;
  20.     Registers[DAC_DATA] = 0x3C9;
  21.   } // End of Constructor for VGADRIVER
  22.  
  23. VGADRIVER::~VGADRIVER ()
  24.   {
  25.   } // End of Destructor for VGADRIVER
  26.  
  27. BOOLEAN VGADRIVER::SetUp ( DISPLAYDATA *Data )
  28.   {
  29.     if (Data)
  30.       {}  
  31.     #if defined (__FORWINDOWS__)
  32.       return FAILURE;
  33.     #elif defined (__FOROS2__)
  34.       return FAILURE;
  35.     #elif defined (__FORDOS__)
  36.       MODEINFO ModeInfo;
  37.       LONG ModeNumber;
  38.  
  39.       CurMode = Data->Mode;
  40.       ModeInfo = ModeTable[Data->Mode];
  41.       ModeNumber = ModeInfo.ModeNumber;
  42.  
  43.       union REGS Regs;
  44.       Regs8.ah = 0;
  45.       Regs8.al = (BYTE)ModeNumber;
  46.       INTERRUPT ( INT_VIDEO, &Regs, &Regs );
  47.       Width = ModeInfo.Width;
  48.       Height = ModeInfo.Height;
  49.       BitSize = ModeInfo.BitSize;
  50.       if (Regs16.ax)
  51.         {}
  52.       SetVGASelector ( SELECTOR_VIDEO );
  53.       return SUCCESS;
  54.     #endif
  55.   } // End of SetUp for VGADRIVER
  56.  
  57. VOID VGADRIVER::Reset ()
  58.   {
  59.     DISPLAYDATA Data;
  60.     Data.Mode = M80x25x16;
  61.     SetUp ( &Data );
  62.   } // End of SetUp for VGADRIVER
  63.  
  64. VOID VGADRIVER::Clear ( HDISPLAY hDisplay, LONG Color )
  65.   {
  66.     if (hDisplay)
  67.       {}
  68.  
  69.     #if defined (__FORDOS__)
  70.       if (CurMode==M320x200x256)
  71.         {
  72.           BYTE* Ptr;
  73.           #if defined (__32BIT__)
  74.             Ptr = (BYTE*)0xA0000;
  75.           #else
  76.             Ptr = (BYTE*)MK_FP(SELECTOR_VIDEO,0);
  77.           #endif
  78.             memset ( Ptr, Color, 320*200 );
  79.         } // End if
  80.     #else
  81.       if (Color)
  82.         {}
  83.     #endif
  84.   } // End of Clear for VGADRIVER
  85.  
  86. LONG VGADRIVER::GetWidth ( HDISPLAY hDisplay )
  87.   {
  88.     if (hDisplay)
  89.       {}
  90.     return Width;
  91.   } // End of GetWidth for VGADRIVER
  92.  
  93. LONG VGADRIVER::GetHeight ( HDISPLAY hDisplay )
  94.   {
  95.     if (hDisplay)
  96.       {}
  97.     return Height;
  98.   } // End of GetHeight for VGADRIVER
  99.  
  100. VOID VGADRIVER::DisplayImage ( IMAGE *Image, LONG Sx, LONG Sy,
  101.                                LONG Wd, LONG Ht, HDISPLAY Dest,
  102.                                LONG Cx, LONG Cy, LONG DestWd, LONG DestHt )
  103.   {
  104.     BYTE *SrcBuffer;
  105.     LONG Format;
  106.  
  107.     if (Dest)
  108.       {}
  109.     Format = Image->GetFormat ();
  110.     SrcBuffer = Image->SetOffset ( Sx, Sy );
  111.     
  112.     if (CurMode==M320x200x256)
  113.       {
  114.         if ((MagH==DivH)&&(MagV==DivV))
  115.           {
  116.             if (Format==IMAGE_8BIT)
  117.               VGACopy256To256 ( SrcBuffer, Image->GetRowInc (), Wd, Ht,
  118.                                 Cx, Cy );
  119.           } // End if
  120.         else
  121.           {
  122.             BYTE *DestBuffer;
  123.             #if defined (__32BIT__)
  124.               DestBuffer = (BYTE*)0xA0000;
  125.             #else
  126.               DestBuffer = (BYTE*)MK_FP(SELECTOR_VIDEO,0);
  127.             #endif
  128.  
  129.             DestBuffer += Cy*Width+Cx;
  130.     
  131.             WORD Error = 0;
  132.             DWORD AddError = (((LONG)DivH<<16)/MagH);
  133.  
  134.             INT i; 
  135.             if (Format==IMAGE_8BIT)
  136.               {
  137.                 for (i=0;i<DestHt;i++)
  138.                   {
  139.                     ScaleBlt256To256 ( DestBuffer, SrcBuffer, DestWd, Error, AddError );
  140.                     SrcBuffer = Image->SetOffset ( Sx, Sy+(i*DivV)/MagV );
  141.                     DestBuffer += Width;
  142.                   } // End for
  143.               } // End if  
  144.           } // End else
  145.       } // End if
  146.   } // End of DisplayImage for VGADRIVER
  147.  
  148. VOID VGADRIVER::SetPalette ( HDISPLAY hDisplay, RGBPALETTE *Pal )
  149.   {
  150.     RGBCOLOR *Entry;
  151.  
  152.     if (hDisplay)
  153.       {}
  154.       
  155.     if (Pal==NULL)
  156.       return;
  157.  
  158.          Entry = Pal->GetEntry ();
  159.          if (Entry==NULL)
  160.       return;
  161.  
  162.     // Update DAC Regsisteres
  163.     #if defined (__FORDOS__)
  164.       INT i;
  165.       outp ( Registers[DAC_MASK], 0xFF );
  166.       outp ( Registers[DAC_WRITE], 0 );
  167.       for (i=0;i<256;i++)
  168.         {
  169.           outp ( Registers[DAC_DATA], Entry[i].Red >> 2 );
  170.           outp ( Registers[DAC_DATA], Entry[i].Green >> 2 );
  171.           outp ( Registers[DAC_DATA], Entry[i].Blue >> 2 );
  172.         } // End for
  173.     #else
  174.     #endif
  175.   } // End of SetPalette for VGADRIVER
  176.  
  177. VOID VGADRIVER::GetPalette ( HDISPLAY hDisplay, RGBPALETTE *Pal )
  178.   {
  179.     INT i;
  180.     RGBCOLOR *Entry;
  181.  
  182.     if (hDisplay)
  183.       {}
  184.     if (Pal==NULL)
  185.       return;
  186.  
  187.     Entry = Pal->GetEntry ();
  188.          if (Entry==NULL)
  189.                 return;
  190.  
  191.     // Update DAC Regsisteres
  192.     #if defined (__FORDOS__)
  193.       outp ( Registers[DAC_MASK], 0xFF );
  194.       outp ( Registers[DAC_READ], 0 );
  195.     #endif
  196.  
  197.     for (i=0;i<256;i++)
  198.       {
  199.         #if defined (__FORDOS__)
  200.           Entry[i].Red = (BYTE)inp ( Registers[DAC_DATA] );
  201.           Entry[i].Green = (BYTE)inp ( Registers[DAC_DATA] );
  202.           Entry[i].Blue = (BYTE)inp ( Registers[DAC_DATA] );
  203.           Entry[i].Red <<= 2;
  204.           Entry[i].Green <<= 2;
  205.           Entry[i].Blue <<= 2;
  206.         #endif
  207.       } // End for
  208.   } // End of GetPalette for VGADRIVER
  209.  
  210. VOID VGADRIVER::DrawLine ( HDISPLAY hDisplay, LONG x1, LONG y1, LONG x2, LONG y2,
  211.                            COLOR  Color )
  212.   {
  213.     INT Dx, Dy;
  214.     INT AddX,AddY;
  215.     INT Len;
  216.  
  217.     if (hDisplay)
  218.       {}
  219.  
  220.     if (x2<x1)
  221.       {
  222.                   AddX = -1;
  223.       } // End if
  224.     else
  225.       AddX = 1;
  226.  
  227.     Dx = abs(x2-x1);
  228.     Dy = abs(y2-y1);
  229.  
  230.          Len = MaxValue ( Dx, Dy ) + 1;
  231.  
  232.     BYTE *Buffer;
  233.  
  234.     #if defined (__32BIT__)
  235.       #if defined (__FORDOS4GW__)
  236.         Buffer = (BYTE*)0xA0000;
  237.       #endif
  238.     #else
  239.       Buffer = (BYTE*)MK_FP(SELECTOR_VIDEO,0);
  240.     #endif
  241.  
  242.     AddY = Width;
  243.     Buffer += y1*AddY;
  244.  
  245.     INT i;
  246.     DWORD Error=0;
  247.  
  248.     DWORD x;
  249.  
  250.     if (Dy==0)
  251.       {
  252.         x = MinValue ( x1, x2 );
  253.         int i;
  254.         Buffer+=x;
  255.         for (i=0;i<Len;i++)
  256.           Buffer[i] = (BYTE)Color;
  257.         //memset ( Buffer+x, Color, Len );
  258.       } // End if
  259.     else
  260.       {
  261.         x = x1;
  262.         if (Dx>Dy)
  263.           {
  264.             for (i=0;i<Len;i++)
  265.               {
  266.                 Buffer[x] = (BYTE)Color;
  267.                 Error += (DWORD)Dy;
  268.                 if (Error>=(DWORD)Dx)
  269.                   {
  270.                     Buffer += AddY;
  271.                     Error -= (DWORD)Dx;
  272.                   } // End Error
  273.                 x += AddX;
  274.               } // End for
  275.           } // End if
  276.         else
  277.           {
  278.             for (i=0;i<Len;i++)
  279.               {
  280.                 Buffer[x] = (BYTE)Color;
  281.                 Error += (DWORD)Dx;
  282.                 if (Error>=(DWORD)Dy)
  283.                   {
  284.                     x += AddX;
  285.                     Error -= (DWORD)Dy;
  286.                   } // End Error
  287.                 Buffer += AddY;
  288.               } // End for
  289.           } // End else
  290.       } // End else
  291.   } // End of DrawLine for VGADRIVER
  292.  
  293. VOID VGADRIVER::DrawRect ( HDISPLAY hDisplay, LONG x1, LONG y1, LONG x2, LONG y2,
  294.                            COLOR Color )
  295.   {
  296.     DrawLine ( hDisplay, x1, y2, x2, y2, Color );
  297.     DrawLine ( hDisplay, x1, y1, x2, y1, Color );
  298.     DrawLine ( hDisplay, x1, y1, x1, y2, Color );
  299.     DrawLine ( hDisplay, x2, y1, x2, y2, Color );
  300.   } // End of DrawRect for VGADRIVER
  301.  
  302. VOID VGADRIVER::FillRect ( HDISPLAY hDisplay, LONG x1, LONG y1, LONG x2, LONG y2,
  303.                            COLOR Color )
  304.   {
  305.     BYTE *Buffer;
  306.  
  307.     if (hDisplay)
  308.       {}
  309.  
  310.     #if defined (__32BIT__)
  311.       #if defined (__FORDOS4GW__)
  312.         Buffer = (BYTE*)0xA0000;
  313.       #endif
  314.     #else
  315.       Buffer = (BYTE*)MK_FP(0xA000,0);
  316.     #endif
  317.  
  318.     LONG AddY = Width;
  319.     LONG Offset;
  320.     Offset = y1*AddY+x1;
  321.  
  322.     INT i;
  323.     LONG Wd, Ht;
  324.  
  325.     Wd = x2-x1+1;
  326.     Ht = y2-y1+1;
  327.  
  328.     for (i=0;i<Ht;i++)
  329.       {
  330.         memset ( Buffer+Offset, Color, Wd );
  331.         Offset += AddY;
  332.       } // End for
  333.   } // End of FillRect for VGADRIVER
  334.  
  335. VOID VGADRIVER::DrawPixel ( HDISPLAY hDisplay, LONG x, LONG y,
  336.                             COLOR Color )
  337.   {
  338.     if (hDisplay)
  339.       {}
  340.  
  341.     if ((x<0)||(x>=Width))
  342.       return;
  343.     if ((y<0)||(y>=Height))
  344.       return;
  345.  
  346.     #if defined (__32BIT__)
  347.       #if defined (__FORDOS4GW__)
  348.         Buffer = (BYTE*)0xA0000;
  349.       #endif
  350.     #else
  351.       Buffer = (BYTE*)MK_FP(0xA000,0);
  352.     #endif
  353.  
  354.     Buffer += y*320+x;
  355.     *Buffer = (BYTE)Color;
  356.   } // End of DrawPixel for VGADRIVER
  357.  
  358. VOID VGADRIVER::DrawEllipsePoint ( HDISPLAY hDisplay, LONG Cx, LONG Cy, LONG x, LONG y, COLOR Color )
  359.   {
  360.     INT Dx,Dy;
  361.  
  362.     Dx = x - Cx;
  363.     Dy = Cy - y;
  364.  
  365.     DrawPixel ( hDisplay, Cx+Dx, Cy-Dy, Color );
  366.     DrawPixel ( hDisplay, Cx+Dx, Cy+Dy, Color );
  367.     DrawPixel ( hDisplay, Cx-Dx, Cy-Dy, Color );
  368.     DrawPixel ( hDisplay, Cx-Dx, Cy+Dy, Color );
  369.   } // End of DrawEllipsePoint for VGADRIVER
  370.  
  371. VOID VGADRIVER::DrawEllipse ( HDISPLAY hDisplay, LONG Cx, LONG Cy, LONG Rx, LONG Ry,
  372.                               COLOR Color )
  373.   {
  374.     LONG RsqX,RsqY;
  375.     LONG RsqXY;
  376.     LONG X2,Y2;
  377.     LONG x,y;
  378.     LONG MidTest;
  379.  
  380.     if ((Rx==0)||(Ry==0))
  381.       return;
  382.  
  383.     RsqX = Rx*Rx;
  384.     RsqY = Ry*Ry;
  385.     RsqXY = RsqX*RsqY;
  386.     x = 0;
  387.     y = Ry;
  388.  
  389.     // Midtest = a^2*x^2 + b^2*y^2 - a^2*b^2
  390.     DrawEllipsePoint ( hDisplay, Cx, Cy, x+Cx,
  391.                        Cy-y, Color );
  392.  
  393.     Y2 = y*y;
  394.     while ((x*RsqY)<=(y*RsqX))
  395.       {
  396.         x++;
  397.         X2 = x*x;
  398.         MidTest = RsqY*X2+RsqX*Y2 - RsqXY;
  399.         if (MidTest>=0)
  400.           {
  401.             y--;
  402.             Y2 = y*y;
  403.           } // End if
  404.         DrawEllipsePoint ( hDisplay, Cx, Cy, x+Cx,
  405.                            Cy-y, Color );
  406.       } // End while
  407.  
  408.     while (y>=0)
  409.       {
  410.         y--;
  411.         Y2 = y*y;
  412.         MidTest = RsqY*X2+RsqX*Y2 - RsqXY;
  413.         if (MidTest<0)
  414.           {
  415.             x++;
  416.             X2 = x*x;
  417.           } // End if
  418.         DrawEllipsePoint ( hDisplay, Cx, Cy, x+Cx,
  419.                            Cy-y, Color );
  420.       } // End while
  421.   } // End of DrawEllipse for VGADRIVER
  422.  
  423. VOID VGADRIVER::DrawHorizLine ( HDISPLAY hDisplay, LONG x1, LONG x2, LONG y, COLOR Color )
  424.   {
  425.     if (hDisplay)
  426.       {}
  427.  
  428.     if (x1>x2)
  429.       SwapValue ( &x1, &x2 );
  430.  
  431.     if (x1<0)
  432.       x1 = 0;
  433.     else if (x1>Width)
  434.       return;
  435.  
  436.     if (x2<0)
  437.       return;
  438.     else if (x2>Width)
  439.       x2 = Width;
  440.  
  441.     if (y<0)
  442.       y = 0;
  443.     else if (y>Height)
  444.       return;
  445.  
  446.     INT Wd;
  447.  
  448.     Wd = x2 - x1 + 1;
  449.  
  450.     BYTE *Buffer;
  451.  
  452.     #if defined (__32BIT__)
  453.       #if defined (__FORDOS4GW__)
  454.         Buffer = (BYTE*)0xA0000;
  455.       #endif
  456.     #else
  457.       Buffer = (BYTE*)MK_FP(0xA000,0);
  458.     #endif
  459.  
  460.     LONG Offset = y*320+x1;
  461.  
  462.     memset ( Buffer+Offset, Color, Wd );
  463.   } // End of DrawHorizLine for VGADRIVER
  464.  
  465. VOID VGADRIVER::FillEllipsePoint ( HDISPLAY hDisplay, LONG Cx, LONG Cy,
  466.                                    LONG x, LONG y, COLOR Color )
  467.   {
  468.     INT Dx,Dy;
  469.  
  470.     if (hDisplay)
  471.       {}
  472.     Dx = x - Cx;
  473.     Dy = Cy - y;
  474.  
  475.     DrawHorizLine ( hDisplay, Cx-Dx, Cx+Dx, Cy-Dy, Color );
  476.     DrawHorizLine ( hDisplay, Cx-Dx, Cx+Dx, Cy+Dy, Color );
  477.   } // End of FillEllipsePoints for VGADRIVER
  478.  
  479. VOID VGADRIVER::FillEllipse ( HDISPLAY hDisplay, LONG Cx, LONG Cy,
  480.                               LONG Rx, LONG Ry, COLOR Color )
  481.   {
  482.     LONG RsqX,RsqY;
  483.     LONG RsqXY;
  484.     LONG X2,Y2;
  485.     LONG x,y;
  486.     LONG MidTest;
  487.  
  488.     if ((Rx==0)||(Ry==0))
  489.       return;
  490.  
  491.     RsqX = Rx*Rx;
  492.     RsqY = Ry*Ry;
  493.     RsqXY = RsqX*RsqY;
  494.     x = 0;
  495.     y = Ry;
  496.  
  497.     // Midtest = a^2*x^2 + b^2*y^2 - a^2*b^2
  498.     FillEllipsePoint ( hDisplay, Cx, Cy, x+Cx,
  499.                        Cy-y, Color );
  500.  
  501.     Y2 = y*y;
  502.     while ((x*RsqY)<=(y*RsqX))
  503.       {
  504.         x++;
  505.         X2 = x*x;
  506.         MidTest = RsqY*X2+RsqX*Y2 - RsqXY;
  507.         if (MidTest>=0)
  508.           {
  509.             y--;
  510.             Y2 = y*y;
  511.           } // End if
  512.         FillEllipsePoint ( hDisplay, Cx, Cy, x+Cx,
  513.                            Cy-y, Color );
  514.       } // End while
  515.  
  516.     while (y>=0)
  517.       {
  518.         y--;
  519.         Y2 = y*y;
  520.         MidTest = RsqY*X2+RsqX*Y2 - RsqXY;
  521.         if (MidTest<0)
  522.           {
  523.             x++;
  524.             X2 = x*x;
  525.           } // End if
  526.         FillEllipsePoint ( hDisplay, Cx, Cy, x+Cx,
  527.                            Cy-y, Color );
  528.       } // End while
  529.   } // End of FillEllipse for VGADRIVER
  530.  
  531.